home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / status.c < prev    next >
C/C++ Source or Header  |  1994-09-15  |  5KB  |  257 lines
  1. #include "wwbbs.h"
  2. #include "status.h"
  3.  
  4. __asm
  5. ULONG GetStatus(register __a0 struct TagItem *tags_orig)
  6.     {
  7.         ULONG ret=0;
  8.         APTR name=NULL;
  9.         BOOL exists=FALSE;
  10.         BOOL isnext=FALSE;struct Node *next=NULL;
  11.         ULONG *nextreturn=NULL;
  12.         {
  13.             struct TagItem *tags;
  14.             if(tags=CloneTagItems(tags_orig))
  15.                 {
  16.                     if(FilterTagItems(tags,st_get_tags,TAGFILTER_AND))
  17.                         {
  18.                             struct TagItem *tstate,*tag;
  19.                             APTR data;
  20.                             tstate=tags;
  21.                             while(tag=NextTagItem(&tstate))
  22.                                 {
  23.                                     data=(APTR) tag->ti_Data;
  24.                                     switch(tag->ti_Tag)
  25.                                         {
  26.                                             case STTAG_Name:
  27.                                                 name=data;
  28.                                                 break;
  29.                                             case STTAG_Exists:
  30.                                                 exists=(BOOL) data;
  31.                                                 break;
  32.                                             case STTAG_Next:
  33.                                                 isnext=TRUE;
  34.                                                 next=data;
  35.                                                 break;
  36.                                             case STTAG_NextReturn:
  37.                                                 nextreturn=data;
  38.                                                 break;
  39.                                             default:
  40.                                                 break;
  41.                                         }
  42.                                 }
  43.                         }
  44.                     FreeTagItems(tags);
  45.                 }
  46.         }
  47.         {
  48.             if(isnext)
  49.                 {
  50.                     struct Node *node=NULL;
  51.                     if(next)
  52.                         {
  53.                             /* next */
  54.                             struct Node *tmp;
  55.                             tmp=next->ln_Succ;
  56.                             if(tmp->ln_Succ)
  57.                                 node=GetStatusNode(tmp->ln_Name,SHARED_LOCK);
  58.                             FreeStatusNode(next);
  59.                         }
  60.                     else
  61.                         {
  62.                             /* begin */
  63.                             ObtainSemaphoreShared(&StatusSemaphore);
  64.                             if(StatusList.lh_Head->ln_Succ)
  65.                                 node=GetStatusNode(StatusList.lh_Head->ln_Name,SHARED_LOCK);
  66.                             ReleaseSemaphore(&StatusSemaphore);
  67.                         }
  68.                     if(node)
  69.                         {
  70.                             ULONG count=0;
  71.                             if(name) { *((STRPTR *) name)=node->ln_Name; count++; }
  72.                             if(exists) count++;
  73.                             count+=GetStatusFields(node,tags_orig);
  74.                             if(nextreturn) *nextreturn=count;
  75.                             ret=(ULONG) node;
  76.                         }
  77.                 }
  78.             else
  79.                 {
  80.                     if(name && strlen((STRPTR) name)) /* Required */
  81.                         {
  82.                             struct Node *node;
  83.                             if(node=GetStatusNode((STRPTR) name,SHARED_LOCK))
  84.                                 {
  85.                                     if(exists) ret++;
  86.                                     ret+=GetStatusFields(node,tags_orig);
  87.                                     FreeStatusNode(node);
  88.                                 }
  89.                         }
  90.                 }
  91.         }
  92.         return(ret);
  93.     }
  94.  
  95. ULONG GetStatusTags(Tag tag,...)
  96.     {
  97.         return(GetStatus((struct TagItem *) &tag));
  98.     }
  99.  
  100. __asm
  101. ULONG SetStatus(register __a0 struct TagItem *tags_orig)
  102.     {
  103.         ULONG ret=0;
  104.         STRPTR name=NULL;
  105.         {
  106.             struct TagItem *tags;
  107.             if(tags=CloneTagItems(tags_orig))
  108.                 {
  109.                     if(FilterTagItems(tags,st_set_tags,TAGFILTER_AND))
  110.                         {
  111.                             struct TagItem *tstate,*tag;
  112.                             APTR data;
  113.                             tstate=tags;
  114.                             while(tag=NextTagItem(&tstate))
  115.                                 {
  116.                                     data=(APTR) tag->ti_Data;
  117.                                     switch(tag->ti_Tag)
  118.                                         {
  119.                                             case STTAG_Name:
  120.                                                 name=data;
  121.                                                 break;
  122.                                         }
  123.                                 }
  124.                         }
  125.                     FreeTagItems(tags);
  126.                 }
  127.         }
  128.         {
  129.             if(name && strlen(name))
  130.                 {
  131.                     struct Node *node;
  132.                     if(node=GetStatusNode(name,EXCLUSIVE_LOCK))
  133.                         {
  134.                             ret+=SetStatusFields(node,tags_orig);
  135.                             FreeStatusNode(node);
  136.                         }
  137.                 }
  138.         }
  139.         if(ret)
  140.             SendUpdate(UPDCMD_UpdateStatus,NULL);
  141.         return(ret);
  142.     }
  143.  
  144. ULONG SetStatusTags(Tag tag,...)
  145.     {
  146.         return(SetStatus((struct TagItem *) &tag));
  147.     }
  148.  
  149. __asm
  150. BOOL AddStatus(register __a0 struct TagItem *tags_orig)
  151.     {
  152.         BOOL ret=FALSE;
  153.         STRPTR name=NULL;
  154.         {
  155.             struct TagItem *tags;
  156.             if(tags=CloneTagItems(tags_orig))
  157.                 {
  158.                     if(FilterTagItems(tags,st_add_tags,TAGFILTER_AND))
  159.                         {
  160.                             struct TagItem *tstate,*tag;
  161.                             APTR data;
  162.                             tstate=tags;
  163.                             while(tag=NextTagItem(&tstate))
  164.                                 {
  165.                                     data=(APTR) tag->ti_Data;
  166.                                     switch(tag->ti_Tag)
  167.                                         {
  168.                                             case STTAG_Name:
  169.                                                 name=data;
  170.                                                 break;
  171.                                         }
  172.                                 }
  173.                         }
  174.                     FreeTagItems(tags);
  175.                 }
  176.         }
  177.         {
  178.             if(name && strlen(name) && strlen(name)<=32)
  179.                 {
  180.                     ObtainSemaphore(&StatusSemaphore);
  181.                     if(!FindName(&StatusList,name))
  182.                         {
  183.                             struct Node *wn=NULL;
  184.                             if(wn=AllocVec(sizeof(struct StatusNode),MEMF_CLEAR))
  185.                                 {
  186.                                     wn->ln_Name=((struct StatusNode *) wn)->sn_NodeName;
  187.                                     InitSemaphore(&(((struct StatusNode *) wn)->sn_Semaphore));
  188.                                     strcpy(((struct StatusNode *) wn)->sn_NodeName,name);
  189.                                     AddTail(&StatusList,wn);
  190.                                     SendUpdate(UPDCMD_UpdateStatus,NULL);
  191.                                     ret=TRUE;
  192.                                 }
  193.                         }
  194.                     ReleaseSemaphore(&StatusSemaphore);
  195.                 }
  196.         }
  197.         return(ret);
  198.     }
  199.  
  200. BOOL AddStatusTags(Tag tag,...)
  201.     {
  202.         return(AddStatus((struct TagItem *) &tag));
  203.     }
  204.  
  205. __asm
  206. BOOL RemStatus(register __a0 struct TagItem *tags_orig)
  207.     {
  208.         BOOL ret=FALSE;
  209.         STRPTR name=NULL;
  210.         {
  211.             struct TagItem *tags;
  212.             if(tags=CloneTagItems(tags_orig))
  213.                 {
  214.                     if(FilterTagItems(tags,st_rem_tags,TAGFILTER_AND))
  215.                         {
  216.                             struct TagItem *tstate,*tag;
  217.                             APTR data;
  218.                             tstate=tags;
  219.                             while(tag=NextTagItem(&tstate))
  220.                                 {
  221.                                     data=(APTR) tag->ti_Data;
  222.                                     switch(tag->ti_Tag)
  223.                                         {
  224.                                             case STTAG_Name:
  225.                                                 name=data;
  226.                                                 break;
  227.                                         }
  228.                                 }
  229.                         }
  230.                     FreeTagItems(tags);
  231.                 }
  232.         }
  233.         {
  234.             if(name && strlen(name))
  235.                 {
  236.                     ObtainSemaphore(&StatusSemaphore);
  237.                     {
  238.                         struct Node *node=NULL;
  239.                         if(node=FindName(&StatusList,name))
  240.                             {
  241.                                 Remove(node);
  242.                                 FreeVec(node);
  243.                                 SendUpdate(UPDCMD_UpdateStatus,NULL);
  244.                                 ret=TRUE;
  245.                             }
  246.                     }
  247.                     ReleaseSemaphore(&StatusSemaphore);
  248.                 }
  249.         }
  250.         return(ret);
  251.     }
  252.  
  253. BOOL RemStatusTags(Tag tag,...)
  254.     {
  255.         return(RemStatus((struct TagItem *) &tag));
  256.     }
  257.